/*************************************************************************
                           Vector2D  -  description
                             -------------------
    début                : 21 févr. 2012
    copyright            : (C) 2012 par francois
*************************************************************************/

//---------- Réalisation de la classe <Vector2D> (fichier Vector2D.cpp) -------

//---------------------------------------------------------------- INCLUDE

//-------------------------------------------------------- Include système
using namespace std;
#include <iostream>
#include <math.h>
//------------------------------------------------------ Include personnel
#include "Vector2D.h"

namespace livgeo {

//------------------------------------------------------------- Constantes

//----------------------------------------------------------------- PUBLIC

//----------------------------------------------------- Méthodes publiques
// type Vector2D::Méthode ( liste des paramtres )
// Algorithme :
//
//{
//} //----- Fin de Méthode

float Vector2D::dot(const Vector2D& v1, const Vector2D& v2)
{
	return (v1.getX() * v2.getX() + v1.getY() * v2.getY());
}

float Vector2D::norm1() const
{
	return x*x + y*y;
}

float Vector2D::norm2() const
{
	return sqrt(norm1());
}

Vector2D Vector2D::rotate(const Point2D& origin, float angle)
{
	Vector2D ret(-origin.getX(), -origin.getY());
	float c=cos(angle);
	float s=sin(angle);
	ret.x = c*x - s*y;
	ret.y = s*x + c*y;

	return ret;
}

float Vector2D::perp(const Vector2D& v1, const Vector2D& v2)
{
	return (v1.getX()*v2.getY() - v1.getY() * v2.getX());
}

float Vector2D::angleBetween(const Vector2D& v1, const Vector2D& v2)
{
	float a = dot(v1, v2)/(v1.norm2()*v2.norm2());

	if (a >= 1) a=1;
	else if (a <= -1) a=-1;

	float angle = acos(a);

	if (perp(v1, v2) < 0)
		return -angle;
	else
		return angle;
}
//------------------------------------------------- Surcharge d'opérateurs

Point2D Vector2D::operator+(const Point2D& p) const
{
	return Point2D(x + p.getX(), y + p.getY());
}

Vector2D& Vector2D::operator+=(const Vector2D& v)
{
	x += v.x;
	y += v.y;
	return (*this);
}

Vector2D& Vector2D::operator-=(const Vector2D& v)
{
	x -= v.x;
	y -= v.y;
	return (*this);
}

Vector2D Vector2D::operator+(const Vector2D& v) const
{
	Vector2D vect;
	vect += v;
	return vect;
}

Vector2D Vector2D::operator-(const Vector2D& v) const
{
	Vector2D vect;
	vect -= v;
	return vect;
}

//-------------------------------------------- Constructeurs - destructeur

Vector2D::Vector2D ( ) :
		x(0), y(0)
{
} //----- Fin de Vector2D

Vector2D::Vector2D ( const Point2D & unPoint2D ) :
		x(unPoint2D.getX()), y(unPoint2D.getY())
{
}

Vector2D::Vector2D (float x, float y) :
		x(x), y(y)
{
}

Vector2D::~Vector2D ( )
{
} //----- Fin de ~Vector2D


//------------------------------------------------------------------ PRIVE

//----------------------------------------------------- Méthodes protégées

}; // ------ fin de livgeo
